---
id: tracker-stores
sidebar_label: Tracker Stores
title: Tracker Stores
description: All conversations are stored within a tracker store. Read how Rasa Open Source provides implementations for different store types out of the box.
abstract: Your assistant's conversations are stored within a tracker store.
  Rasa Open Source provides implementations for different store types out of the box,
  or you can create your own custom one.
---

<!-- this file is version specific, do not use `@site/...` syntax -->
import variables from './variables.json';

## InMemoryTrackerStore (default)

`InMemoryTrackerStore` is the default tracker store. It is used if no other
tracker store is configured. It stores the conversation history in memory.

:::note
As this store keeps all history in memory, the entire history is lost if you restart the Rasa server.

:::



### **Configuration**

No configuration is needed to use the `InMemoryTrackerStore`.


## SQLTrackerStore

You can use an `SQLTrackerStore` to store your assistant's conversation history in an SQL database.

### Configuration

To set up Rasa Open Source with SQL the following steps are required:

1. Add required configuration to your `endpoints.yml`:

 ```yaml-rasa title="endpoints.yml"
 tracker_store:
     type: SQL
     dialect: "postgresql"  # the dialect used to interact with the db
     url: ""  # (optional) host of the sql db, e.g. "localhost"
     db: "rasa"  # path to your db
     username:  # username used for authentication
     password:  # password used for authentication
     query: # optional dictionary to be added as a query string to the connection URL
       driver: my-driver
 ```

2. To start the Rasa server using your SQL backend,
 add the `--endpoints` flag, e.g.:

 ```bash
 rasa run -m models --endpoints endpoints.yml
 ```

3. If deploying your model in Docker Compose, add the service to your `docker-compose.yml`:

 ```yaml-rasa title="docker-compose.yml"
 postgres:
   image: postgres:latest
 ```

 To route requests to the new service, make sure that the `url` in your `endpoints.yml`
 references the service name:

 ```yaml-rasa {4} title="endpoints.yml"
   tracker_store:
       type: SQL
       dialect: "postgresql"  # the dialect used to interact with the db
       url: "postgres"
       db: "rasa"  # path to your db
       username:  # username used for authentication
       password:  # password used for authentication
       query: # optional dictionary to be added as a query string to the connection URL
         driver: my-driver
 ```

#### Configuration Parameters

* `domain` (default: `None`): Domain object associated with this tracker store

* `dialect` (default: `sqlite`): The dialect used to communicate with your SQL backend.  Consult the [SQLAlchemy docs](https://docs.sqlalchemy.org/en/latest/core/engines.html#database-urls) for available dialects.

* `url` (default: `None`): URL of your SQL server

* `port` (default: `None`): Port of your SQL server

* `db` (default: `rasa.db`): The path to the database to be used

* `username` (default: `None`): The username which is used for authentication

* `password` (default: `None`): The password which is used for authentication

* `event_broker` (default: `None`): Event broker to publish events to

* `login_db` (default: `None`): Alternative database name to which initially  connect, and create the database specified by `db` (PostgreSQL only)

* `query` (default: `None`): Dictionary of options to be passed to the dialect and/or the DBAPI upon connect



#### Compatible Databases

The following databases are officially compatible with the `SQLTrackerStore`:
  * PostgreSQL
  * Oracle > 11.0
  * SQLite

#### Configuring Oracle

To use the SQLTrackerStore with Oracle, there are a few additional steps.
First, create a database `tracker` in your Oracle database and create a user with access to it.
Create a sequence in the database with the following command, where username is the user you created
(read more about creating sequences in the [Oracle Documentation](https://docs.oracle.com/cd/B28359_01/server.111/b28310/views002.htm#ADMIN11794)):

```sql
CREATE SEQUENCE username.events_seq;
```

Next you have to extend the Rasa Open Source image to include the necessary drivers and clients.
First download the [Oracle Instant Client](https://www.oracle.com/database/technologies/instant-client/linux-x86-64-downloads.html),
rename it to `oracle.rpm` and store it in the directory from where you'll be building the docker image.
Copy the following into a file called `Dockerfile`:

<pre><code parentName="pre" className="language-bash">
{`FROM rasa/rasa:${variables.release}-full

# Switch to root user to install packages
USER root

RUN apt-get update -qq && apt-get install -y --no-install-recommends alien libaio1 && apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*

# Copy in oracle instaclient
# https://www.oracle.com/database/technologies/instant-client/linux-x86-64-downloads.html
COPY oracle.rpm oracle.rpm

# Install the Python wrapper library for the Oracle drivers
RUN pip install cx-Oracle

# Install Oracle client libraries
RUN alien -i oracle.rpm

USER 1001`}
</code></pre>

Then build the docker image:

<pre><code parentName="pre" className="language-bash">
{`docker build . -t rasa-oracle:${variables.release}-oracle-full`}
</code></pre>

Now you can configure the tracker store in the `endpoints.yml` as described above,
and start the container. The `dialect` parameter with this setup will be `oracle+cx_oracle`.
Read more about [Deploying Your Rasa Assistant](./how-to-deploy.mdx).


## RedisTrackerStore

You can store your assistant's conversation history in [Redis](https://redis.io/) by using the
`RedisTrackerStore`.
Redis is a fast in-memory key-value store which can optionally also persist data.



### Configuration

To set up Rasa Open Source with Redis the following steps are required:

1. Start your Redis instance

2. Add required configuration to your `endpoints.yml`:

 ```yaml-rasa title="endpoints.yml"
 tracker_store:
     type: redis
     url: <url of the redis instance, e.g. localhost>
     port: <port of your redis instance, usually 6379>
     key_prefix: <alphanumeric value to prepend to tracker store keys>
     db: <number of your database within redis, e.g. 0>
     password: <password used for authentication>
     use_ssl: <whether or not the communication is encrypted, default `false`>
 ```

 ```bash
 rasa run -m models --endpoints endpoints.yml
 ```

4. If deploying your model in Docker Compose, add the service to your `docker-compose.yml`:

 ```yaml-rasa title="docker-compose.yml"
 redis:
   image: redis:latest
 ```

 To route requests to the new service, make sure that the `url` in your `endpoints.yml`
 references the service name:

 ```yaml-rasa {3} title="endpoints.yml"
  tracker_store:
      type: redis
      url: <url of the redis instance, e.g. localhost>
      port: <port of your redis instance, usually 6379>
      db: <number of your database within redis, e.g. 0>
      key_prefix: <alphanumeric value to prepend to tracker store keys>
      password: <password used for authentication>
      use_ssl: <whether or not the communication is encrypted, default `false`>
 ```

* `url` (default: `localhost`): The url of your redis instance

* `port` (default: `6379`): The port which redis is running on

* `db` (default: `0`): The number of your redis database

* `key_prefix` (default: `None`): The prefix to prepend to tracker store keys. Must
    be alphanumeric

* `password` (default: `None`): Password used for authentication
(`None` equals no authentication)

* `record_exp` (default: `None`): Record expiry in seconds

* `use_ssl` (default: `False`): whether or not to use SSL for transit encryption


## MongoTrackerStore


You can store your assistant's conversation history in [MongoDB](https://www.mongodb.com/) using the `MongoTrackerStore`.
MongoDB is a free and open-source cross-platform document-oriented NoSQL database.

### Configuration

1. Start your MongoDB instance.

2. Add required configuration to your `endpoints.yml`:

 ```yaml-rasa title="endpoints.yml"
 tracker_store:
     type: mongod
     url: <url to your mongo instance, e.g. mongodb://localhost:27017>
     db: <name of the db within your mongo instance, e.g. rasa>
     username: <username used for authentication>
     password: <password used for authentication>
     auth_source: <database name associated with the user's credentials>
 ```

 You can also add more advanced configurations (like enabling ssl) by appending
 a parameter to the url field, e.g. `mongodb://localhost:27017/?ssl=true`.

3. To start the Rasa server using your configured MongoDB instance,
 add the `--endpoints` flag, for example:

 ```bash
 rasa run -m models --endpoints endpoints.yml
 ```

4. If deploying your model in Docker Compose, add the service to your `docker-compose.yml`:

 ```yaml-rasa title="docker-compose.yml"
 mongo:
   image: mongo
   environment:
     MONGO_INITDB_ROOT_USERNAME: rasa
     MONGO_INITDB_ROOT_PASSWORD: example
 mongo-express:  # this service is a MongoDB UI, and is optional
   image: mongo-express
   ports:
     - 8081:8081
   environment:
     ME_CONFIG_MONGODB_ADMINUSERNAME: rasa
     ME_CONFIG_MONGODB_ADMINPASSWORD: example
 ```

 To route requests to this database, make sure to set the `url` in your `endpoints.yml` as the service name,
 and specify the user and password:

 ```yaml-rasa {3,5,6} title="endpoints.yml"
  tracker_store:
      type: mongod
      url: mongodb://mongo:27017
      db: <name of the db within your mongo instance, e.g. rasa>
      username: <username used for authentication>
      password: <password used for authentication>
      auth_source: <database name associated with the user's credentials>
 ```



#### Configuration Parameters

* `url` (default: `mongodb://localhost:27017`): URL of your MongoDB

* `db` (default: `rasa`): The database name which should be used

* `username` (default: `0`): The username which is used for authentication

* `password` (default: `None`): The password which is used for authentication

* `auth_source` (default: `admin`): database name associated with the user's credentials.

* `collection` (default: `conversations`): The collection name which is
used to store the conversations


## DynamoTrackerStore

You can store your assistant's conversation history in
[DynamoDB](https://aws.amazon.com/dynamodb/) by using a `DynamoTrackerStore`.
DynamoDB is a hosted NoSQL database offered by Amazon Web Services (AWS).


### Configuration

1. Start your DynamoDB instance.

2. Add required configuration to your `endpoints.yml`:

 ```yaml-rasa title="endpoints.yml"
 tracker_store:
     type: dynamo
     table_name: <name of the table to create, e.g. rasa>
     region: <name of the region associated with the client>
 ```

3. To start the Rasa server using your configured `DynamoDB` instance,
 add the `--endpoints` flag, e.g.:

 ```bash
 rasa run -m models --endpoints endpoints.yml
 ```


#### Configuration Parameters

* `table_name` (default: `states`): name of the DynamoDB table

* `region` (default: `us-east-1`): name of the region associated with the client


## Custom Tracker Store

If you need a tracker store which is not available out of the box, you can implement your own.
This is done by extending the base class `TrackerStore`.

To write a custom tracker store, extend the `TrackerStore` base class. Your constructor has to
provide a parameter `host`.

### Configuration

 In your `endpoints.yml` put in the module path to your custom tracker store
 and the parameters you require:

 ```yaml-rasa title="endpoints.yml"
 tracker_store:
   type: path.to.your.module.Class
   url: localhost
   a_parameter: a value
   another_parameter: another value
 ```

If you are deploying in Docker Compose, you have two options to add this store to Rasa Open Source:
extending the Rasa image to include the module, or mounting the module as volume.

 Make sure to add the corresponding service as well. For example, mounting it as a volume would look like so:

 ```yaml {5,6,7} title="docker-compose.yml"
 rasa:
   <existing rasa service configuration>
   volumes:
     - <existing volume mappings, if there are any>
     - ./path/to/your/module.py:/app/path/to/your/module.py
 custom-tracker-store:
   image: custom-image:tag
 ```

 ```yaml-rasa {3} title="endpoints.yml"
 tracker_store:
   type: path.to.your.module.Class
   url: custom-tracker-store
   a_parameter: a value
   another_parameter: another value
 ```
